package demo.java.util;

import org.junit.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class OptionalDemo {

    public static void main(String[] args) {
    }

    @Test
    public void testNullPointer() {
        Map<String, Map<String, Integer>> map = null;
        Optional<Integer> optional = Optional.ofNullable(map)
                .map(e -> e.get("1"))
                .map(e -> e.get("2"));
        System.err.println(optional.orElse(-1));
    }

    /**
     * 可以通过利用 Java 8 的 Optional 类型来摆脱所有这些 null 检查。
     * map 方法接收一个 Function 类型的 lambda 表达式， 并自动将每个 function
     * 的结果包装成一个Optional对象。这使我们能够在一行中进行多个 map 操作。Null 检查是在底层自动处理的。
     * <p>
     * 这种方案可能没有传统 null 检查那么高的性能。不过在大多数情况下不会有太大问题。
     */
    @Test
    public void testNullPointer2() {
        Map<String, Map<String, Integer>> map = new HashMap<>();
        Optional<Integer> optional = Optional.of(map)
                .map(e -> e.get("1"))
                .map(e -> e.get("2"));
        System.err.println(optional.orElse(-1));
    }

    @Test
    public void testOf() {
        Integer i = null;
        Optional<Object> o = Optional.of(i);
        System.err.println(o.orElse(new Integer(-1)));
    }

    @Test
    public void testOfNullable() {
        Integer i = null;
        Optional<Object> o2 = Optional.ofNullable(i);
        System.err.println(o2.orElse(-1));
    }

    @Test
    public void testOrElse() {
        Object a = Optional
                .ofNullable(null)
                .orElse(1 + 2);
        System.out.println(a);
    }


    @Test
    public void testOrElseGet() {
        Object a = Optional
                .ofNullable(null)
                .orElseGet(() -> sum(1, 2));
        System.out.println(a);
    }

    public int sum(int a, int b) {
        return a + b;
    }
}
